home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d16 / winvn060.arc / NEWDES2.C < prev    next >
Text File  |  1991-07-01  |  6KB  |  202 lines
  1. /*--- newdes2.c -- Program to implement the NEWDES algorithm.
  2.  *
  3.  *   See Robert Scott's article "Wide-open Encryption Design Offers
  4.  *   Flexible Implementations" in Volume 9, Number 1 (January 1985)
  5.  *   of Cryptologia.
  6.  *   This algorithm resembles the Data Encryption Standard, but is easier
  7.  *   to implement in software and is supposed to be more secure.
  8.  *
  9.  *   Based on my March 1988 8086 assembly language version.
  10.  *
  11.  *   Mark Riordan    12 August 1990.
  12.  */
  13.  
  14. #define SIZE_ROTOR     256
  15. #define SIZE_KEY_UNRAV     60
  16. #define SIZE_USER_KEY     15
  17. #define BLOCK_BYTES     8
  18.  
  19. unsigned int newdes_buf(unsigned char *buf,unsigned int block_length);
  20. void newdes_block(unsigned char *block);
  21. void newdes_set_key_encipher(unsigned char *key);
  22. void newdes_set_key_decipher(unsigned char *key);
  23.  
  24. unsigned char newdes_rotor[SIZE_ROTOR]
  25.  = {
  26.     32,137,239,188,102,125,221, 72,212, 68, 81, 37, 86,237,147,149,
  27.     70,229, 17,124,115,207, 33, 20,122,143, 25,215, 51,183,138,142,
  28.    146,211,110,173,  1,228,189, 14,103, 78,162, 36,253,167,116,255,
  29.    158, 45,185, 50, 98,168,250,235, 54,141,195,247,240, 63,148,  2,
  30.    224,169,214,180, 62, 22,117,108, 19,172,161,159,160, 47, 43,171,
  31.    194,175,178, 56,196,112, 23,220, 89, 21,164,130,157,  8, 85,251,
  32.    216, 44, 94,179,226, 38, 90,119, 40,202, 34,206, 35, 69,231,246,
  33.     29,109, 74, 71,176,  6, 60,145, 65, 13, 77,151, 12,127, 95,199,
  34.     57,101,  5,232,150,210,129, 24,181, 10,121,187, 48,193,139,252,
  35.    219, 64, 88,233, 96,128, 80, 53,191,144,218, 11,106,132,155,104,
  36.     91,136, 31, 42,243, 66,126,135, 30, 26, 87,186,182,154,242,123,
  37.     82,166,208, 39,152,190,113,205,114,105,225, 84, 73,163, 99,111,
  38.    204, 61,200,217,170, 15,198, 28,192,254,134,234,222,  7,236,248,
  39.    201, 41,177,156, 92,131, 67,249,245,184,203,  9,241,  0, 27, 46,
  40.    133,174, 75, 18, 93,209,100,120, 76,213, 16, 83,  4,107,140, 52,
  41.     58, 55,  3,244, 97,197,238,227,118, 49, 79,230,223,165,153, 59
  42. };
  43.  
  44. unsigned char newdes_key_unravelled[SIZE_KEY_UNRAV];
  45.  
  46.  
  47. /*--- function newdes_buf -------------------------------------------
  48.  *
  49.  * Encipher or decipher a buffer of data.
  50.  *
  51.  *    Entry    buf          points to the buffer.
  52.  *           block_length   is the number of bytes in the buffer.
  53.  *                  If it is not a multiple of 8, it will be
  54.  *                  rounded up to the next multiple of 8--
  55.  *                  so make sure that the buffer is long enough.
  56.  *           newdes_key_unravelled   points to the key.  It has
  57.  *            been "unravelled" as necessary for either
  58.  *            enciphering or deciphering.
  59.  *           newdes_rotor   is the fundamental mapping function
  60.  *                  (array) for NEWDES.
  61.  *
  62.  *    Exit     Returns the number of bytes now in the buffer
  63.  *         (rounded up as described above).
  64.  */
  65. unsigned int
  66. newdes_buf(buf,block_length)
  67. unsigned char *buf;
  68. unsigned int block_length;
  69. {
  70.    unsigned int mylen, mylen2;
  71.  
  72.    if(block_length > 0) {
  73.       mylen2 = mylen = (((block_length - 1) / BLOCK_BYTES) + 1) * BLOCK_BYTES;
  74.    }
  75.  
  76.    for(;mylen; mylen -= BLOCK_BYTES){
  77.       newdes_block(buf);
  78.       buf += BLOCK_BYTES;
  79.    }
  80.  
  81.    return(mylen2);
  82. }
  83.  
  84. /*--- function newdes_block -----------------------------------------
  85.  *
  86.  *  Encipher or decipher an 8-byte block.
  87.  *
  88.  *    Entry    block    points to the block.
  89.  *           newdes_key_unravelled   points to the key.  It has
  90.  *            been "unravelled" as necessary for either
  91.  *            enciphering or deciphering.
  92.  *           newdes_rotor   is the fundamental mapping function
  93.  *                  (array) for NEWDES.
  94.  */
  95. void
  96. newdes_block(block)
  97. unsigned char *block;
  98. {
  99.    unsigned char *keyptr = newdes_key_unravelled;
  100.    register unsigned char *byteptr = block;
  101.    int count;
  102.  
  103. #define B0 (*byteptr)
  104. #define B1 (*(byteptr+1))
  105. #define B2 (*(byteptr+2))
  106. #define B3 (*(byteptr+3))
  107. #define B4 (*(byteptr+4))
  108. #define B5 (*(byteptr+5))
  109. #define B6 (*(byteptr+6))
  110. #define B7 (*(byteptr+7))
  111.  
  112.    for(count=8; count--;) {
  113.       B4 = B4 ^ newdes_rotor[B0 ^ *(keyptr++)];
  114.       B5 = B5 ^ newdes_rotor[B1 ^ *(keyptr++)];
  115.       B6 = B6 ^ newdes_rotor[B2 ^ *(keyptr++)];
  116.       B7 = B7 ^ newdes_rotor[B3 ^ *(keyptr++)];
  117.  
  118.       B1 = B1 ^ newdes_rotor[B4 ^ *(keyptr++)];
  119.       B2 = B2 ^ newdes_rotor[B4 ^ B5];
  120.       B3 = B3 ^ newdes_rotor[B6 ^ *(keyptr++)];
  121.       B0 = B0 ^ newdes_rotor[B7 ^ *(keyptr++)];
  122.    }
  123.    B4 = B4 ^ newdes_rotor[B0 ^ *(keyptr++)];
  124.    B5 = B5 ^ newdes_rotor[B1 ^ *(keyptr++)];
  125.    B6 = B6 ^ newdes_rotor[B2 ^ *(keyptr++)];
  126.    B7 = B7 ^ newdes_rotor[B3 ^ *(keyptr++)];
  127. }
  128.  
  129. /*--- function newdes_set_key_encipher ---------------------------------
  130.  *
  131.  *    Set newdes to encipher using a given key.
  132.  *
  133.  *    Entry    key   points to a 15-byte key.
  134.  *
  135.  *    Exit     newdes_key_unravelled   contains the key set up properly
  136.  *             for use in newdes_block, for enciphering.
  137.  */
  138. void
  139. newdes_set_key_encipher(key)
  140. unsigned char *key;
  141. {
  142.    unsigned char *kuserptr, *kunravptr;
  143.    int outloopct = SIZE_KEY_UNRAV / SIZE_USER_KEY;
  144.    int inloopct;
  145.  
  146.    kunravptr = newdes_key_unravelled;
  147.    for(;outloopct--;) {
  148.       kuserptr = key;
  149.       for(inloopct=SIZE_USER_KEY; inloopct--;) {
  150.      *(kunravptr++) = *(kuserptr++);
  151.       }
  152.    }
  153. }
  154.  
  155.  
  156. /*--- function newdes_set_key_decipher ---------------------------------
  157.  *
  158.  *    Set newdes to decipher using a given key.
  159.  *
  160.  *    Entry    key   points to a 15-byte key.
  161.  *
  162.  *    Exit     newdes_key_unravelled   contains the key set up properly
  163.  *             for use in newdes_block, for deciphering.
  164.  */
  165. void
  166. newdes_set_key_decipher(key)
  167. unsigned char *key;
  168. {
  169.    unsigned char *kuserptr, *kunravptr;
  170.    int outloopct = SIZE_KEY_UNRAV / SIZE_USER_KEY;
  171.    int inloopct;
  172.    int userkeyidx;
  173.  
  174.    kunravptr = newdes_key_unravelled;
  175.    userkeyidx = 11;
  176.    while (1) {
  177.       *(kunravptr++) = key[userkeyidx];
  178.       userkeyidx++;
  179.       if(userkeyidx == SIZE_USER_KEY) userkeyidx = 0;
  180.  
  181.       *(kunravptr++) = key[userkeyidx];
  182.       userkeyidx++;
  183.       if(userkeyidx == SIZE_USER_KEY) userkeyidx = 0;
  184.  
  185.       *(kunravptr++) = key[userkeyidx];
  186.       userkeyidx++;
  187.       if(userkeyidx == SIZE_USER_KEY) userkeyidx = 0;
  188.  
  189.       *(kunravptr++) = key[userkeyidx];
  190.       userkeyidx = (userkeyidx+9) % 15;
  191.  
  192.       if(userkeyidx == 12) break;
  193.  
  194.       *(kunravptr++) = key[userkeyidx++];
  195.       *(kunravptr++) = key[userkeyidx++];
  196.  
  197.       *(kunravptr++) = key[userkeyidx];
  198.  
  199.       userkeyidx = (userkeyidx+9) % 15;
  200.    }
  201. }
  202.